//package com.information.manage.common.watcher;
//
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
//import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
//import com.information.manage.basic.common.result.Result;
//import com.information.manage.basic.common.utils.PathUtils;
//import com.information.manage.basic.common.utils.RedisUtils;
//import com.information.manage.basic.service.DepartmentService;
//import com.information.manage.common.annotation.CsvField;
//import com.information.manage.common.constants.*;
//import com.information.manage.dao.AddFileMapper;
//import com.information.manage.dao.AnalysisFileMapper;
//import com.information.manage.model.dto.AddFile;
//import com.information.manage.model.entity.AddFileDO;
//import com.information.manage.model.entity.AnalysisFileDo;
//import com.information.manage.model.excel.CsvAnalysis;
//import lombok.AllArgsConstructor;
//import lombok.Data;
//import lombok.NoArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.collections4.CollectionUtils;
//import org.apache.commons.csv.CSVFormat;
//import org.apache.commons.csv.CSVParser;
//import org.apache.commons.csv.CSVRecord;
//import org.apache.commons.lang3.StringUtils;
//import org.mozilla.universalchardet.UniversalDetector;
//import org.springframework.beans.BeanUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.boot.CommandLineRunner;
//import org.springframework.scheduling.annotation.EnableScheduling;
//import org.springframework.scheduling.annotation.Scheduled;
//import org.springframework.stereotype.Component;
//import org.springframework.transaction.TransactionStatus;
//import org.springframework.transaction.support.TransactionCallbackWithoutResult;
//import org.springframework.transaction.support.TransactionTemplate;
//import org.springframework.util.Assert;
//
//import javax.annotation.Resource;
//import java.io.*;
//import java.lang.reflect.Field;
//import java.nio.charset.Charset;
//import java.nio.file.*;
//import java.nio.file.attribute.BasicFileAttributes;
//import java.util.*;
//import java.util.concurrent.*;
//import java.util.stream.Collectors;
//
//@Slf4j
//@Component
//@EnableScheduling
//@SuppressWarnings("all")
//public class DirectoryWatcher implements CommandLineRunner {
//
//    @Value("${base.watchDirPath:/usr/local/tmp}")
//    private String watchDirPath;
//
//    // 监听类型： 咨询、短讯、短篇
//    @Value("${base.watchDir:consulting,short_message,short_article}")
//    private String listenDirs;
//
//    @Value("${base.classifyTypeCollection:2}")
//    private Long classifyTypeCollection;
//
//    @Value("${base.addEnclosuresDir:add_enclosures}")
//    private String addEnclosuresDir;
//
//    @Value("${base.autoCreate:false}")
//    private Boolean autoCreate;
//
//    @Value("${base.generate.upload.suffix:_upload}")
//    private String generateUploadSuffix;
//
//    @Resource(name = "taskExecutor")
//    private Executor taskExecutor;
//
//    @Resource(name = "listenExecutor")
//    private Executor listenExecutor;
//
//    @Autowired
//    private RedisUtils redisUtils;
//
//    @Autowired
//    private AddFileMapper addFileMapper;
//
//    @Autowired
//    private AnalysisFileMapper analysisFileMapper;
//
//    @Autowired
//    private TransactionTemplate transactionTemplate;
//
//    @Autowired
//    private DepartmentService departmentService;
//
//    private static final String addFileKey = "add_file";
//    private static final String classifyKey = "dir_classify";
//
//    // 检测任务是否已经开始
//    private static volatile Boolean taskIsStart = Boolean.FALSE;
//
//    @Override
//    public void run(String... args) throws Exception {
//        if (StringUtils.isEmpty(addEnclosuresDir)){
//            log.info("--------未配置添加时附件路径");
//        }else {
//            // 此处跟需要监听的路径一起创建， 但是该目录不会被监听，仅仅用于添加时保存附件
//            String addEnclosuresDirPath = PathUtils.builderPath(watchDirPath, addEnclosuresDir);
//            File file = new File(addEnclosuresDirPath);
//            if (!file.exists() || !file.isDirectory()){
//                file.mkdir();
//            }
//            log.info("--------添加时附件路径已处理完毕");
//        }
//
//        // 如果是分布式 此处需要加锁 todo
//        if (StringUtils.isEmpty(listenDirs)) {
//            log.info("---------未配置监听目录，不进行处理");
//            return;
//        }
//        String[] split = listenDirs.split(",");
//        for (String dir : split) {
//            if (!ListenTypeEnum.belongListenType(dir)) {
//                log.info("------不进行监听的类型：{}", dir);
//                continue;
//            }
//            String listenPathDir = PathUtils.builderPath(watchDirPath, dir);
//            log.info("监听文件路径：{}", listenPathDir);
//            // 先判断路径是否存在
//            File file = new File(listenPathDir);
//            if (!file.exists() || !file.isDirectory()) {
//                if (autoCreate) {
//                    boolean mkdir = file.mkdirs();
//                    Assert.isTrue(mkdir, "自动创建文件夹失败，在路径下可能存在相同名的文件");
//                } else {
//                    throw new RuntimeException("监听路径不存在，请手动创建或者添加配置自动创建");
//                }
//            }
//            this.startWatching(listenPathDir);
//        }
//        this.startTask();
//    }
//
//    /**
//     * 开启监听文件夹下文件变化
//     * 稳定的方式：在监听到变化后应先发送到mq进行处理，此处未接入mq，就直接进行处理
//     * @param watchDirPath
//     */
//    private void startWatching(String watchDirPath) {
//        listenExecutor.execute(()-> {
//            try (WatchService watchService = FileSystems.getDefault().newWatchService()) {
//                registerDirectories(Paths.get(watchDirPath), watchService);
//
//                while (true) {
//                    WatchKey key = watchService.take();
//                    for (WatchEvent<?> event : key.pollEvents()) {
//                        WatchEvent.Kind<?> kind = event.kind();
//
//                        if (kind == StandardWatchEventKinds.OVERFLOW) {
//                            continue;
//                        }
//
//                        WatchEvent<Path> ev = (WatchEvent<Path>) event;
//                        Path filename = ev.context();
//                        Path path = ((Path) key.watchable()).resolve(filename);
//                        File file = new File(path.toUri());
//                        String kindName = kind.name();
//                        AddFile addFile = new AddFile(file.getName(), file.getAbsolutePath(), kindName, new Date());
//                        redisUtils.rPush(addFileKey, addFile);
//                        log.info("-----检测到文件:{}写入", file.getName());
//                    }
//
//                    boolean valid = key.reset();
//                    if (!valid) {
//                        log.info("-----exit");
//                        break;
//                    }
//                }
//            } catch (IOException | InterruptedException e) {
//                log.error("Error watching directories", e);
//            }
//        });
//    }
//
//    @Scheduled(cron = "0 */1 * * * ?")
//    public void scheduledWriteAddFileToMysql() {
//        // 如果是分布式 此处需要加锁 todo
//        Long listSize = redisUtils.getListSize(addFileKey);
//        log.info("------check add file size:{}", listSize);
//        Long count = 1000L; // 一次处理的最大数量
//        while (listSize > count){
//            writeAddFileToMysql(count);
//            listSize = redisUtils.getListSize(addFileKey);
//        }
//        writeAddFileToMysql(listSize);
//    }
//
//    private void writeAddFileToMysql(Long count){
//        if (count == 0) return;
//        // 事务中处理加入数据  防止中途处理异常 导致数据重复添加
//        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
//            @Override
//            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
//                List<AddFile> list =  redisUtils.lRange(addFileKey, 0, count-1).stream().map(it -> (AddFile) it).collect(Collectors.toList());
//                // 写入mysql
//                List<AddFileDO> addFileDOList = new ArrayList<>();
//                for (AddFile addFile : list) {
//                    AddFileDO addFileDO = new AddFileDO();
//                    BeanUtils.copyProperties(addFile, addFileDO);
//                    addFileDO.setStatus(AddFileStatusEnum.NOT_START.getCode());
//                    addFileDO.setCreateTime(new Date());
//                    String fileName = addFile.getFileName();
//                    if (fileName.endsWith(generateUploadSuffix)){ // 上传的
//                        addFileDO.setType(HandleFileTypeEnum.UPLOAD.getCode());
//                        String tmp = fileName.substring(0, fileName.indexOf(generateUploadSuffix));
//                        String userId = tmp.substring(tmp.lastIndexOf("_")+1);
//                        addFileDO.setOperator(Long.valueOf(userId));
//                    }else {
//                        addFileDO.setType(HandleFileTypeEnum.LISTEN.getCode());
//                        addFileDO.setOperator(0L);
//                    }
//
//                    String filePath = addFile.getFilePath();
//                    String tmpBasePath = filePath.substring(0, filePath.lastIndexOf(File.separator));
//                    String fileType = tmpBasePath.substring(tmpBasePath.lastIndexOf(File.separator)+1);
//                    Integer fileTypeCode = ListenTypeEnum.getFileTypeCode(fileType);
//                    addFileDO.setListenFileTypeCode(fileTypeCode);
//                    addFileDOList.add(addFileDO);
//                }
//                addFileMapper.insertList(addFileDOList);
//                redisUtils.lPop(addFileKey, count);
//            }
//        });
//
//        // 添加成功后 提醒开始任务
//        this.startTask();
//    }
//
//    /**
//     * 开始任务 检测未执行处理的文件夹并执行
//     */
//    private void startTask(){
//        if (!taskIsStart){
//            log.info("任务开始");
//            taskIsStart = Boolean.TRUE;
//            // 循环检测mysql表中任务是否已经完成  每次只处理10条
//            List<AddFileDO> addFileDOList;
//            do {
//                addFileDOList = addFileMapper.selectList(new LambdaQueryWrapper<AddFileDO>()
//                        .eq(AddFileDO::getStatus, AddFileStatusEnum.NOT_START.getCode()).orderByAsc(AddFileDO::getId).last("limit 10"));
//                List<CompletableFuture> taskList = new ArrayList<>();
//                for (AddFileDO addFileDO : addFileDOList) {
//                    CompletableFuture<TaskResult> task = CompletableFuture.supplyAsync(() -> {
//                        ProcessFileEventRes processFileEventRes = null;
//                        try {
//                            processFileEventRes = processFileEvent(new File(addFileDO.getFilePath()), addFileDO.getKindName(), addFileDO.getListenFileTypeCode());
//                        } catch (IOException e) {
//                            throw new RuntimeException(e);
//                        }
//                        TaskResult taskResult = new TaskResult(addFileDO.getId(), processFileEventRes);
//                        return taskResult;
//                    }, taskExecutor);
//                    taskList.add(task);
//                }
//                CompletableFuture.allOf(taskList.toArray(new CompletableFuture[0])).join();
//                for (CompletableFuture future : taskList) {
//                    try {
//                        TaskResult taskResult = (TaskResult) future.get();
//                        Long id = taskResult.getId();
//                        ProcessFileEventRes processFileEventRes = taskResult.getProcessFileEventRes();
//                        LambdaUpdateWrapper<AddFileDO> updateWrapper = new LambdaUpdateWrapper<AddFileDO>().eq(AddFileDO::getId, id)
//                                .set(AddFileDO::getResult, processFileEventRes.getMessage()).set(AddFileDO::getStatus, AddFileStatusEnum.FINISH.getCode())
//                                .set(AddFileDO::getUpdateTime, new Date());
//                        if (processFileEventRes.getStatus() == 0){  // 处理成功的 存在id需要加入
//                            List<Long> analysisFileIds = processFileEventRes.getAnalysisFileId();
//                            if (CollectionUtils.isNotEmpty(analysisFileIds)){  // 获取第一个值进行保存，其它的则新增为子数据
//                                Long analysisFileId = analysisFileIds.get(0);
//                                updateWrapper.set(AddFileDO::getAnalysisFileId, analysisFileId);
//                                addFileMapper.update(null, updateWrapper);
//                                // 处理子数据
//                                analysisFileIds.remove(analysisFileId);
//                                if (CollectionUtils.isNotEmpty(analysisFileIds)){
//                                    AddFileDO addFileDO = addFileMapper.selectById(id);
//                                    addFileDO.setParentId(addFileDO.getId());
//                                    addFileDO.setId(null);
//                                    List<AddFileDO> needAddFileDOS = new ArrayList<>();
//                                    for (Long fileId : analysisFileIds) {
//                                        AddFileDO newAddFileDo = new AddFileDO();
//                                        BeanUtils.copyProperties(addFileDO, newAddFileDo);
//                                        newAddFileDo.setAnalysisFileId(fileId);
//                                        needAddFileDOS.add(newAddFileDo);
//                                    }
//                                    addFileMapper.insertList(needAddFileDOS);
//                                }
//                            }else {
//                                addFileMapper.update(null, updateWrapper);
//                            }
//                        }else {
//                            addFileMapper.update(null, updateWrapper);
//                        }
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    } catch (ExecutionException e) {
//                        e.printStackTrace();
//                    }
//                }
//            }while (addFileDOList.size() != 0);
//
//            // 任务全部完成后标志置为false
//            taskIsStart = Boolean.FALSE;
//            log.info("----任务结束");
//        }else {
//            log.info("任务正在进行中");
//        }
//    }
//
//    @Data
//    @AllArgsConstructor
//    @NoArgsConstructor
//    class TaskResult {
//        private Long id;
//        private ProcessFileEventRes processFileEventRes;
//    }
//
//
//    private void registerDirectories(Path dir, WatchService watchService) throws IOException {
//        Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
//            @Override
//            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
//                // 目前先只监听文件创建
//                dir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE);
//                return FileVisitResult.CONTINUE;
//            }
//        });
//    }
//
//    private ProcessFileEventRes processFileEvent(File file, String kindName, Integer listenFileTypeCode) throws IOException {
//        if (kindName.equals(StandardWatchEventKinds.ENTRY_CREATE.name())) {
//            // 文件被创建，读取文件内容并进行处理
//            log.info("File {} has been {}", file.getAbsoluteFile(), kindName);
//            // 只处理文件夹，目前的需求为样例数据中（文件夹下）存在一个csv文件和一个子文件夹存放附件
//            if (file.isDirectory()) {
//                // 处理csv文件
//                List<CsvAnalysis> csvAnalysisList = handleCsv(file);
//                if (CollectionUtils.isNotEmpty(csvAnalysisList)){
//                    List<Long> resIds = new ArrayList<>();
//                    for (CsvAnalysis csvAnalysis : csvAnalysisList) {
//                        try {
////                            if (StringUtils.isNotEmpty(csvAnalysis.getPath())) {  // 附件存在 处理附件
////                                try {
////                                    handleEnclosure(file, csvAnalysis);
////                                }catch (Exception e){
////                                    log.info("handle {} enclosure dir path fail:{}", file.getAbsoluteFile(), e);
////                                    continue;
////                                }
////                            }
//                            try {
//                                handleInsidePath(file, csvAnalysis, "path");   // 处理附件路径
//                                handleInsidePath(file, csvAnalysis, "summaryPath");  // 处理概述路径
//                            }catch (Exception e){
//                                log.info("handle {} inside dir path fail:{}", file.getAbsoluteFile(), e);
//                                continue;
//                            }
//
//                            log.info("analysis get data：{}", csvAnalysis);
//                            // 存储该数据
//                            AnalysisFileDo analysisFileDo = new AnalysisFileDo();
//                            BeanUtils.copyProperties(csvAnalysis, analysisFileDo);
//                            analysisFileDo.setStorageTime(new Date());
//                            analysisFileDo.setSummary(csvAnalysis.getSummary());
//                            analysisFileDo.setFileType(FileTypeEnum.CSV.getDes());
//                            analysisFileDo.setListenFileTypeCode(listenFileTypeCode);
//                            analysisFileDo.setDeleteData(0);
//                            analysisFileDo.setClassifyId(getClassifyId(analysisFileDo.getTypeTag()));
//                            analysisFileMapper.insert(analysisFileDo);
//                            resIds.add(analysisFileDo.getId());
//                        } catch (Exception e) {
//                            log.error("=========> 解析出错！");
//                            log.error("analysis file fail:{}", e.getMessage());
//                            continue;
//                        }
//                    }
//                    return new ProcessFileEventRes("analysis success", 0, resIds);
//                }
//            }else {
//                log.info("file:{} handle fail", file.getAbsoluteFile());
//                return new ProcessFileEventRes("file handle fail", 1, null);
//            }
//        } else if (kindName.equals(StandardWatchEventKinds.ENTRY_MODIFY.name())) {
//            // 文件被修改，读取文件内容并进行处理
//        } else if (kindName.equals(StandardWatchEventKinds.ENTRY_DELETE.name())) {
//            // 文件被删除
//        }
//        return new ProcessFileEventRes("other type, not handle", 1, null);
//    }
//
//    private Long getClassifyId(String typeTag){
//        Long tagId = 0L;
//        if (StringUtils.isEmpty(typeTag)) return tagId;
//        // 转换tag   目前样式为 气象-政策
//        String[] split = typeTag.split("-");
//        StringBuilder stringBuilder = new StringBuilder();
//        for (String s : split) {
//            stringBuilder.append("/").append(s);
//        }
//        stringBuilder.deleteCharAt(0); // 移除掉第一位/
//        String path = stringBuilder.toString();
//
//        Object o = redisUtils.hmGet(classifyKey, path);
//        if (o == null){   // 可能需要更新缓存
//            redisUtils.remove(classifyKey);
//            setClassifyCache();
//            // 从redis中获取全路径
//            o = redisUtils.hmGet(classifyKey, path);
//            if (o != null){
//                tagId = Long.valueOf(o.toString());
//            }
//            return tagId;
//        }else {
//            tagId = Long.valueOf(o.toString());
//            return tagId;
//        }
//
//    }
//
//    private synchronized void setClassifyCache(){
//        if (!redisUtils.exists(classifyKey)) {  // 双重校验 避免多线程时重复执行
//            List<Integer> ids = departmentService.getIdsByTypeCollection(classifyTypeCollection);
//            Map<Integer, String> map = departmentService.queryDepartmentNameById(ids);
//            for (Integer key : map.keySet()) {
//                redisUtils.hmSet(classifyKey, map.get(key), key, 12L, TimeUnit.HOURS);
//            }
//        }
//    }
//
//    @Data
//    @AllArgsConstructor
//    @NoArgsConstructor
////    @Builder
//    class ProcessFileEventRes {
//        private String message;
//        private Integer status;  // 0表示成功 1表示失败
//        private List<Long> analysisFileId;
//    }
//
//
//    /**
//     * 检测文件编码
//     *
//     * @param fis 文件流
//     * @return 文件编码
//     * @throws IOException 如果检测失败
//     */
//    private static String detectCharset(FileInputStream fis) throws IOException {
//        byte[] buf = new byte[4096];
//        try {
//            UniversalDetector detector = new UniversalDetector(null);
//            int nread;
//            while ((nread = fis.read(buf)) > 0 && !detector.isDone()) {
//                detector.handleData(buf, 0, nread);
//            }
//            detector.dataEnd();
//            String encoding = detector.getDetectedCharset();
//            detector.reset();
//            return encoding;
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
//    }
//
//    /**
//     * 处理csv文件
//     * @param newFile  当前文件夹
//     * @Return 附件地址
//     */
//    private static List<CsvAnalysis> handleCsv(File newFile) throws IOException {
//        File[] files = confirmDirWriteFinish(newFile);
//
//        if (files.length == 0) {
//            log.info("目录下不存在文件");
//            return null;
//        }
//        // 目前先认定只有一个csv文件+一个附件
//        File csvFile = Arrays.stream(files).filter(it -> it.getPath().endsWith(".csv")).collect(Collectors.toList()).stream().findFirst().orElse(null);
//        if (csvFile != null){
//            FileInputStream fileInputStream = new FileInputStream(csvFile);
//            String encoding = detectCharset(fileInputStream);
//            fileInputStream.close();
//            try(FileInputStream fis = new FileInputStream(csvFile);
//
//                BufferedReader reader = new BufferedReader(new InputStreamReader(fis, Charset.forName(encoding)));
//                            CSVParser parser = CSVParser.parse(reader, CSVFormat.DEFAULT.withFirstRecordAsHeader().withIgnoreHeaderCase().withTrim())) {
//
//                List<String> headerNames = parser.getHeaderNames();
//
//                // 获取所有记录
//                List<CSVRecord> records = parser.getRecords();
//                List<Map<String, String>> listMap = new ArrayList<>();
//                for (CSVRecord record : records) {
//                    Map<String, String> map = new HashMap<>(headerNames.size());
//                    for (int i = 0; i < headerNames.size(); i++) {
//                        String key = headerNames.get(i);
//                        String value = record.get(i);
//                        map.put(key, value);
//                    }
//                    listMap.add(map);
//                }
//
//                if (listMap.size() == 0){
//                    log.info("未从csv文件中解析到数据");
//                    return null;
//                }
//
//                List<CsvAnalysis> res = new ArrayList<>();
//                for (Map<String, String> map : listMap) {
//                    if (map.size() == 0) continue;
//                    CsvAnalysis csvAnalysis = dataTransform(map);
//                    res.add(csvAnalysis);
//                }
//
//                parser.close();
//                return res;
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }else {
//            log.info("目录下不存在csv文件");
//        }
//        return null;
//    }
//
//    private static CsvAnalysis dataTransform(Map<String, String> map){
//        CsvAnalysis csvAnalysis = new CsvAnalysis();
//        for (Field declaredField : csvAnalysis.getClass().getDeclaredFields()) {
//            CsvField annotation = declaredField.getAnnotation(CsvField.class);
//            String value = map.get(annotation.name());
//            if (StringUtils.isNotEmpty(value)){
//                try {
//                    declaredField.setAccessible(true);
//                    Object convertValue = DataType.convertValue(value, annotation.dataType());
//                    declaredField.set(csvAnalysis, convertValue);
//                } catch (IllegalAccessException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//        }
//        return csvAnalysis;
//    }
//
//    /**
//     * 确认检测到的新文件夹中文件已经写入完毕
//     * @param newFile
//     * @return
//     */
//    private static File[] confirmDirWriteFinish(File newFile){
//        File[] files = newFile.listFiles();
//        // 可能新加入的目录还未完全写入，故此处读不到，需要重试，当检测到文件内多次不存在变化时，则认定读取完毕
//        Integer curRetryCount = 0;
//        Integer maxRetryCount = 3;
//        while (true){
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
//            File[] newFiles = newFile.listFiles();
//            Integer distance = newFiles.length - files.length;
//            files = newFiles;
//            if (distance == 0){
//                curRetryCount ++;
//                if (curRetryCount == maxRetryCount) break;
//            }else {
//                curRetryCount = 0;
//            }
//        }
//        return files;
//    }
//
//
//    /**
//     * 处理附件
//     * @param file 当前文件
//     */
//    private void handleEnclosure(File file, CsvAnalysis csvAnalysis){
//        // 获取到附件的绝对路径
//        Path absolutePath = file.toPath().resolve(csvAnalysis.getPath());
//        File enclosureDir = new File(absolutePath.normalize().toUri());
//        if (enclosureDir.isDirectory()) throw new RuntimeException("this enclosure path is not file");
//        csvAnalysis.setPath(enclosureDir.getAbsolutePath());
//    }
//
//    /**
//     * 处理内部路径
//     * @param file
//     * @param csvAnalysis
//     * @param fieldName
//     */
//    private void handleInsidePath(File file, CsvAnalysis csvAnalysis, String fieldName){
//        try {
//            Field declaredField = csvAnalysis.getClass().getDeclaredField(fieldName);
//            declaredField.setAccessible(true);
//            String path = String.valueOf(declaredField.get(csvAnalysis));
//            if (StringUtils.isNotEmpty(path) && !"null".equals(path)){
//                Path absolutePath = file.toPath().resolve(path);
//                File enclosureDir = new File(absolutePath.normalize().toUri());
//                if (enclosureDir.isDirectory()) throw new RuntimeException("this enclosure path is not file");
//                declaredField.set(csvAnalysis, enclosureDir.getAbsolutePath());
//            }
//        } catch (NoSuchFieldException e) {
//            throw new RuntimeException(e);
//        } catch (IllegalAccessException e) {
//            throw new RuntimeException(e);
//        }
//    }
//
//
//    /**
//     * 做一个任务补偿，如果中途出现意外，防止检测到到的文件一直不被解析
//     */
//    @Scheduled(cron = "0 */10 * * * ?")
//    public void taskCheck(){
//        if (!taskIsStart){  // 如果任务未开始 才判断是否还存在需要执行的任务
//            log.info("------任务未开始，进行探测");
//            Integer count = addFileMapper.selectCount(new LambdaQueryWrapper<AddFileDO>()
//                    .eq(AddFileDO::getStatus, AddFileStatusEnum.NOT_START.getCode()).last("limit 1"));
//            if (count != 0){
//                log.info("-----需要开始任务");
//                this.startTask();  // 通知开始任务
//            }else {
//                log.info("-----不需要执行任务");
//            }
//        }
//    }
//
//}